/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Berekenen;

import Delta.Lamel;
import Domain.Data;
//import Domain.Lamel;
//import Domain.Laminaat;
import Domain.Materiaal;
import Exceptions.NameAlreadyExistsException;
import Jama.Matrix;
import Delta.Layer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Memet
 */
public class MaakMatrix {

    /**
     * Maakt een matrix met daarin de posities van de lamellen
     * @param lam Matrix met lamellen
     * @return matrix met daarin de posities van de lamellen
     */
    public static Matrix Diktes(Matrix lam) {
        //Matrix met diktes aanmaken
        Matrix d = lam.getMatrix(0, lam.getRowDimension() - 1, 3, 3);
        //Aantal rijen vaststellen
        int n = d.getRowDimension();
        //Output matrix aanmaken
        Matrix ld = new Matrix(n, 2);
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += d.get(i, 0);
//        }
        //Middellijn bepalen
        double h0 = 0.5 * dikte;
        //Positie bovenste lamel vaststellen
        ld.set(0, 0, h0);
        //Matrix vullen
        for (int i = 0; i < n; i++) {
            ld.set(i, 1, (ld.get(i, 0) - d.get(i, 0))); //Matlab: LD(i,2)=LD(i,1)-d(i,1);
            if (i < (n - 1)) {
                ld.set(i + 1, 0, ld.get(i, 1)); //Matlab: LD(i+1,1)=LD(i,2);
            }
        }
        //Matrix geven
        return ld;

    }

    /**
     * Berekend de Compliantiematrix van A
     * @param a rekstijfheidsmatrix
     * @param b koppelstijfheidsmatrix
     * @param d buigstijfheidsmatrix
     * @return Compliantiematrix van A
     */
    public static Matrix CompliantieA(Matrix a, Matrix b, Matrix d) {
        Matrix out = null;
        try {
            Matrix dInv = d.inverse();
            out = (a.minus(b.times(dInv).times(b))); //a=inv(A-B*Dinv*B)
            out = out.inverse();

        } catch (RuntimeException ex) {
            ex.printStackTrace();
        } finally {
            return out;
        }
    }

    /**
     * Berekend de Compliantiematrix van B
     * @param a rekstijfheidsmatrix
     * @param b koppelstijfheidsmatrix
     * @param d buigstijfheidsmatrix
     * @return Compliantiematrix van B
     */
    public static Matrix CompliantieB(Matrix a, Matrix b, Matrix d) {
        return (((CompliantieA(a, b, d).times(-1)).times(b)).times(d.inverse()));//b=-a*B*Dinv
    }

    /**
     * Berekend de Compliantiematrix van D
     * @param a rekstijfheidsmatrix
     * @param b koppelstijfheidsmatrix
     * @param d buigstijfheidsmatrix
     * @return Compliantiematrix van D
     */
    public static Matrix CompliantieD(Matrix a, Matrix b, Matrix d) {
        return (d.minus(b.times(a.inverse()).times(b))).inverse(); //d=inv(D-B*Ainv*B)
    }

    /**
     * Berekend de Q matrix van het laminaat
     * @param el de longitudinale stijfheid van het lamel (Pa)
     * @param et de transversale stijfheid van het lamel (Pa)
     * @param mult longitudinale transversale poissonverhouding van het lamel
     * @param mutl transversale longitudinale poissonverhouding van het lamel
     * @param glt longitudinale transversale glijdingsmodulus van het lamel (Pa)
     * @return de Q matrix van het lamel
     */
    public static Matrix Q(double el, double et, double mult, double mutl, double glt) {
//        el *= 1e9;
//        et *= 1e9;
//        glt *= 1e9;


//                % componenten matrix berekenen:
//                Q11 = El/(1-Mult*Mutl) ; % [Pa]
//                Q22 = Et/(1-Mult*Mutl) ; % [Pa]
//                Q12 = (Mutl*El)/(1-Mult*Mutl) ; % [Pa] Q12=Q21
//                Q66 = Glt ; % [Pa]
//                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        double q11 = el / (1 - mult * mutl);
        double q22 = et / (1 - mult * mutl);
        double q12 = (mutl * el) / (1 - mult * mutl); //q12 == q21
        double q66 = glt;

        //matrix aanmaken
        Matrix q = new Matrix(3, 3);
        q.set(0, 0, q11);
        q.set(0, 1, q12);
        q.set(1, 0, q12);
        q.set(1, 1, q22);
        q.set(2, 2, q66);
        //matrix geven
        return q;

    }

    /**
     * Berekend de Tinv matrix van het lamel
     * @param hoek de hoek van het lamel
     * @return de Tinv matrix van het lamel
     */
    public static Matrix Tmat(double hoek) {
//        %% Ingeven hoek Theta
        double th = ((2 * Math.PI) / 360) * hoek;

//        %% Aanmaken elementen T-matrix
        double c = Math.cos(th);
        double s = Math.sin(th);
//
//        % T-matrix aanmaken:
//        % T is nodig voor S-matrix, Tinv wordt gebruikt voor Qmatrix.
//        % T=[c^2 s^2 2*c*s;
//        %      s^2 c^2 -2*c*s;
//        %      -c*s c*s c^2-s^2] ;
        Matrix t = new Matrix(3, 3);

        t.set(0, 0, c * c);
        t.set(0, 1, s * s);
        t.set(0, 2, 2 * c * s);

        t.set(1, 0, s * s);
        t.set(1, 1, c * c);
        t.set(1, 2, (-2) * c * s);

        t.set(2, 0, (-c) * s);
        t.set(2, 1, c * s);
        t.set(2, 2, (c * c) - (s * s));
//        % Nu inverse van T aanmaken (T-1)
//        % niet via >>inv(T) ; te omslachtig. Maar via eq. 3.62, blz 57 van I.Daniel
//        Tinv = [c^2 s^2 -2*c*s;
//                s^2 c^2 2*c*s;
//                c*s -c*s c^2-s^2] ;
        Matrix tInv = new Matrix(3, 3);

        tInv.set(0, 0, c * c);
        tInv.set(0, 1, s * s);
        tInv.set(0, 2, (-2) * c * s);

        tInv.set(1, 0, s * s);
        tInv.set(1, 1, c * c);
        tInv.set(1, 2, 2 * c * s);

        tInv.set(2, 0, c * s);
        tInv.set(2, 1, (-c) * s);
        tInv.set(2, 2, (c * c) - (s * s));

        for (int j = 0; j < tInv.getRowDimension(); j++) {
            for (int i = 0; i < tInv.getColumnDimension(); i++) {
                if (Math.abs(tInv.get(j, i)) < 1e-4) {
                    tInv.set(j, i, 0);
                }
            }
        }





        return tInv;
    }

    /**
     * Berekend de A matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @return De A matrix
     */
    public static Matrix A(Matrix lam, Data data) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //a matrix maken
        Matrix a = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0)); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            a.plusEquals(qt.times((hb - ho))); // resultaten toevoegen aan matrix
        }


//        for(int j = 0; j<a.getRowDimension(); j++)
//        {
//            for(int i = 0; i<a.getColumnDimension(); i++)
//            {
//                if(Math.abs(a.get(j, i))<1e-4)
//                {
//                    a.set(j, i, 0);
//                }
//                //a.set(j, i, Calc.Round(a.get(j, i),3));
//            }
//        }


        return a;
    }

    /**
     * Berekend de A matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @param grad het aantal graden
     * @return De A matrix
     */
    public static Matrix A(Matrix lam, Data data, int grad) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //a matrix maken
        Matrix a = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0) - grad); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            a.plusEquals(qt.times((hb - ho))); // resultaten toevoegen aan matrix
        }


//        for(int j = 0; j<a.getRowDimension(); j++)
//        {
//            for(int i = 0; i<a.getColumnDimension(); i++)
//            {
//                if(Math.abs(a.get(j, i))<1e-4)
//                {
//                    a.set(j, i, 0);
//                }
//                //a.set(j, i, Calc.Round(a.get(j, i),3));
//            }
//        }


        return a;
    }

    /**
     * Berekend de B matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @return De B matrix
     */
    public static Matrix B(Matrix lam, Data data) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //b matrix maken
        Matrix b = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0)); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            double test2 = (hb * hb) - (ho * ho);
            Matrix test3 = qt.times(test2);
            Matrix test4 = test3.times(0.5);
            //Matrix test = qt.times((hb * hb) - (ho * ho)).times(1/2);
            //b.plusEquals(qt.times((hb * hb) - (ho * ho)).times(1/2)); // resultaten toevoegen aan matrix
            double val1 = test4.get(2, 2);
            double val2 = b.get(2, 2);
//            double val1 = Calc.Round(test4.get(2, 2),30);
//            double val2 = Calc.Round(b.get(2, 2),30);
            double val3 = val1 + val2;


            b = b.plus(test4);
            b.set(2, 2, val3);
            //B=B+(1/2)*Qt*(hb^2-ho^2);
        }

//        for(int j = 0; j<b.getRowDimension(); j++)
//        {
//            for(int i = 0; i<b.getColumnDimension(); i++)
//            {
//                if(Math.abs(b.get(j, i))<1e-4)
//                {
//                    b.set(j, i, 0);
//                }
//                //b.set(j, i, Calc.Round(b.get(j, i),3));
//            }
//        }

        return b;
    }

    /**
     * Berekend de B matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @param grad het aantal graden
     * @return De B matrix
     */
    public static Matrix B(Matrix lam, Data data, int grad) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //b matrix maken
        Matrix b = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0) - grad); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            double test2 = (hb * hb) - (ho * ho);
            Matrix test3 = qt.times(test2);
            Matrix test4 = test3.times(0.5);
            //Matrix test = qt.times((hb * hb) - (ho * ho)).times(1/2);
            //b.plusEquals(qt.times((hb * hb) - (ho * ho)).times(1/2)); // resultaten toevoegen aan matrix
            double val1 = Calc.Round(test4.get(2, 2), 30);
            double val2 = Calc.Round(b.get(2, 2), 30);
            double val3 = val1 + val2;


            b = b.plus(test4);
            b.set(2, 2, val3);
            //B=B+(1/2)*Qt*(hb^2-ho^2);
        }

//        for(int j = 0; j<b.getRowDimension(); j++)
//        {
//            for(int i = 0; i<b.getColumnDimension(); i++)
//            {
//                if(Math.abs(b.get(j, i))<1e-4)
//                {
//                    b.set(j, i, 0);
//                }
//                //b.set(j, i, Calc.Round(b.get(j, i),3));
//            }
//        }

        return b;
    }

    /**
     * Berekend de D matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @return De D matrix
     */
    public static Matrix D(Matrix lam, Data data) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //d matrix maken
        Matrix d = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0)); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            double hbb = (hb * hb * hb);
            double hob = (ho * ho * ho);
            double hbo = hbb - hob;
            Matrix tussen = qt.times(hbo);
            double val = (1.0 / 3.0);
            Matrix ans = tussen.times(val);
            d.plusEquals(ans);
            // d = d.plus(qt.times(1 / 3).times(((hb * hb * hb) - (ho * ho * ho))));
            //D=D+(1/3)*Qt*(hb^3-ho^3)
        }

//        for(int j = 0; j<d.getRowDimension(); j++)
//        {
//            for(int i = 0; i<d.getColumnDimension(); i++)
//            {
//                if(Math.abs(d.get(j, i))<1e-4)
//                {
//                    d.set(j, i, 0);
//                }
//                //d.set(j, i, Calc.Round(d.get(j, i),3));
//            }
//        }
        return d;
    }

    /**
     * Berekend de D matrix
     * @param lam Het lamel
     * @param data De databank met alle materialen
     * @param grad het aantal graden
     * @return De D matrix
     */
    public static Matrix D(Matrix lam, Data data, int grad) {
        // Per lamel eigenschappen bepalen
        Matrix ld = MaakMatrix.Diktes(lam); // diktes lamel
        Matrix m = lam.getMatrix(0, lam.getRowDimension() - 1, 1, 1); // materiaal lamel
        Matrix r = lam.getMatrix(0, lam.getRowDimension() - 1, 2, 2); // hoek lamel
        int n = lam.getRowDimension(); // aantal lamellen
        //Dikte initialiseren
        double dikte = Calc.H(lam);
        //Totale dikte berekenen
//        for(int i=0;i<n;i++)
//        {
//            dikte += ld.get(i, 0);
//        }
        double h = dikte; //dikte
        //d matrix maken
        Matrix d = new Matrix(3, 3);
        //door de lamel lopen
        for (int j = 0; j < n; j++) {
            int mat = (int) m.get(j, 0); //materiaalnummer
            Materiaal materiaal = data.getMateriaal(mat);
            Matrix q = materiaal.getQ(); // qmatrix ophalen
            double hb = ld.get(j, 0); // bovenkant lamel
            double ho = ld.get(j, 1); // onderkant lamel
            Matrix tInv = Tmat(r.get(j, 0) - grad); //inverse T matrix
            Matrix qt = tInv.times(q).times(tInv.transpose()); // QT matrix
            double hbb = (hb * hb * hb);
            double hob = (ho * ho * ho);
            double hbo = hbb - hob;
            Matrix tussen = qt.times(hbo);
            double val = (1.0 / 3.0);
            Matrix ans = tussen.times(val);
            d.plusEquals(ans);
            // d = d.plus(qt.times(1 / 3).times(((hb * hb * hb) - (ho * ho * ho))));
            //D=D+(1/3)*Qt*(hb^3-ho^3)
        }

//        for(int j = 0; j<d.getRowDimension(); j++)
//        {
//            for(int i = 0; i<d.getColumnDimension(); i++)
//            {
//                if(Math.abs(d.get(j, i))<1e-4)
//                {
//                    d.set(j, i, 0);
//                }
//                //d.set(j, i, Calc.Round(d.get(j, i),3));
//            }
//        }
        return d;
    }

    /**
     * Matrix met waarden om grafieken te maken
     * @param lam de matrix van het laminaat
     * @param data de database
     * @return Matrix met waarden om grafieken te maken
     */
    public static Matrix Mxtc(Matrix lam, Data data) {
        int eindhoek = 360; // van 0 tot 360 graden
        int staphoek = 1; // in stappen van ... graden
        int aantstap = eindhoek / staphoek + 1; // aantal stappen
        Matrix out = new Matrix(aantstap, 6);
        int grad = 0; // eerste hoek is 0-graden
        for (int gind = 0; gind < aantstap; gind++) {
            double e1 = Calc.E1(lam, data, grad);
            double e2 = Calc.E2(lam, data, grad);
            double mu12 = Calc.Mu12(lam, data, grad);
            double mu21 = Calc.Mu21(lam, data, grad);
            double g12 = Calc.G12(lam, data, grad);
            out.set(gind, 0, grad);
            out.set(gind, 1, e1);
            out.set(gind, 2, e2);
            out.set(gind, 3, mu12);
            out.set(gind, 4, mu21);
            out.set(gind, 5, g12);
            grad += staphoek;
        }

        return out;
    }

    public static Matrix Alpha(double al, double at) {
        Matrix out = new Matrix(3, 1);
        out.set(0, 0, al);
        out.set(1, 0, at);
        out.set(2, 0, 0);
        return out;
    }

    public static Matrix AlphaMat(Matrix q, Matrix alpha) {
        return AlphaMat(q, alpha, 0);
    }

    public static Matrix AlphaMat(Matrix q, Matrix alpha, double hoek) {
        Matrix tinv = Tmat(hoek);


        Matrix alphaTemp = tinv.times(alpha);

        Matrix temp = new Matrix(3, 1);
        temp.set(0, 0, 1);
        temp.set(1, 0, 1);
        temp.set(2, 0, 2);
        alphaTemp = alphaTemp.arrayTimes(temp);
        return alphaTemp;
    }

    public static Matrix Qtr(Matrix q) {
        return Qtr(q, 0);
    }

    public static Matrix Qtr(Matrix q, double hoek) {
        Matrix tinv = Tmat(hoek);
        //Qtrp = Tinvp * Q * Tinvp' ; % Qtrans plus 45
        Matrix qtr = tinv.times(q);
        qtr = qtr.times(tinv.inverse());
        return qtr;
    }

    public static Matrix Nt(Matrix lam, Data data) {
        Matrix nt = new Matrix(3, 1);
        int rowCount = lam.getRowDimension();
        for (int k = 1; k < rowCount; k++) {
            Materiaal mat = data.getMateriaal((int) lam.get(k, 1));
            Matrix qtrm = MaakMatrix.Qtr(mat.getQ());
            Matrix qtrp = qtrm;
            Matrix alphaMin = MaakMatrix.AlphaMat(mat.getQ(), MaakMatrix.Alpha(mat.getA1(), mat.getA2()));
            Matrix alphaPlus = alphaMin;
            double dikte = lam.get(k, 3);
            if ((k % 2) == 1) {
                //odd
                nt = nt.plus(qtrm.times(alphaMin).times(dikte));
            } else {
                //even
                nt = nt.plus(qtrp.times(alphaPlus).times(dikte));
            }
        }
        return nt;
    }

    public static Matrix Mt(Matrix lam, Data data) {
        Matrix mt = new Matrix(3, 1);
        int rowCount = lam.getRowDimension();

        for (int k = 1; k < rowCount; k++) {
            Materiaal mat = data.getMateriaal((int) lam.get(k, 1));
            Matrix qtrm = MaakMatrix.Qtr(mat.getQ());
            Matrix qtrp = qtrm;
            Matrix alphaMin = MaakMatrix.AlphaMat(mat.getQ(), MaakMatrix.Alpha(mat.getA1(), mat.getA2()));
            Matrix alphaPlus = alphaMin;
            Matrix diktes = MaakMatrix.Diktes(lam);
            if ((k % 2) == 1) {
                //odd
                mt = mt.plus(qtrm.times(alphaMin).times(Math.pow(diktes.get(k, 0), 2) - Math.pow(diktes.get(k, 1), 2)));
            } else {
                //even
                mt = mt.plus(qtrp.times(alphaPlus).times(Math.pow(diktes.get(k, 0), 2) - Math.pow(diktes.get(k, 1), 2)));
            }
        }
        mt.times(0.5);
        return mt;
    }

    public static Matrix NMmat(Matrix nt, Matrix mt) {
        Matrix out = new Matrix(6, 1);
        out.setMatrix(0, 2, 0, 0, nt);
        out.setMatrix(3, 5, 0, 0, mt);
        return out;
    }

    public static Matrix EKMat(Matrix nmMat, Matrix a, Matrix b, Matrix d) {
        Matrix comp = new Matrix(6, 6);
        comp.setMatrix(0, 2, 0, 2, CompliantieA(a, b, d));
        comp.setMatrix(3, 5, 0, 2, CompliantieB(a, b, d));
        comp.setMatrix(0, 2, 3, 5, CompliantieB(a, b, d));
        comp.setMatrix(3, 5, 3, 5, CompliantieD(a, b, d));
        Matrix ek = comp.times(nmMat);
        return ek;
    }

    public static Matrix AnglePlyData(Lamel l) {
        return null;
//       Matrix matrix = new Matrix(180, 6);
//        try {
//            Data data = new Data();
//            try{
//                data.addFiber(l.getMyFiber());
//                data.addEpoxy(l.getMyEpoxy());
//            } catch (Exception ex)
//            {
//
//            }
//            data.addLamel(l);
//
//
//
//            int t = -90;
//            for (int i = 0; i < 180; i++) {
//                matrix.set(i, 0, i);
//                matrix.set(i, 1, t);
//                Laminaat lam = new Laminaat();
//                lam.addRowAfter(l, 0, 1);
//                lam.addRowAfter(l, t, 1);
//                lam.addRowAfter(l, t, 1);
//                lam.addRowAfter(l, 0, 1);
//                matrix.set(i, 2, Calc.E1(lam.getLam(), data)/1e9);
//                matrix.set(i, 3, Calc.G12(lam.getLam(), data)/1e9);
//                matrix.set(i, 4, Calc.Mu12(lam.getLam(), data));
//                matrix.set(i, 5, Calc.A1(lam.getLam(), data));
//                t++;
//            }
//        } catch (NameAlreadyExistsException ex) {
//            Logger.getLogger(MaakMatrix.class.getName()).log(Level.SEVERE, null, ex);
//        }
//       return matrix;
    }
}
